/**
 * 内容分割和管理工具
 * 提供小说内容解析、章节分割和格式化功能
 */

import { parseChapters, formatChapterContent } from './parser';

/**
 * 内容管理工具，用于处理内存中的内容
 */
export const contentManager = {
  // 存储内容片段的映射
  contentChunks: new Map(),
  
  // 添加内容片段
  addChunk(chunkId, content) {
    this.contentChunks.set(chunkId, content);
  },
  
  // 获取内容片段
  getChunk(chunkId) {
    return this.contentChunks.get(chunkId);
  },
  
  // 清除所有内容片段
  clearChunks() {
    this.contentChunks.clear();
  },
  
  // 清除指定小说的所有内容片段
  clearNovelChunks(novelId) {
    const chunksToDelete = [];
    this.contentChunks.forEach((_, key) => {
      if (key.startsWith(`${novelId}_`)) {
        chunksToDelete.push(key);
      }
    });
    
    chunksToDelete.forEach(key => this.contentChunks.delete(key));
  }
};

/**
 * 按照最大字符数将内容分割成章节
 * @param {string} content 完整内容
 * @param {number} maxCharsPerChapter 每章最大字符数
 * @returns {Array} 章节数组
 */
export function splitContentIntoChunks(content, maxCharsPerChapter = 10000) {
  if (!content || typeof content !== 'string') {
    console.error('无效的内容格式');
    return [];
  }
  
  console.log(`开始分割内容，总长度: ${content.length}, 最大章节长度: ${maxCharsPerChapter}`);
  
  // 首先尝试识别章节
  try {
    const chapters = parseChapters(content, 'temp');
    
    if (chapters && chapters.length > 0) {
      console.log(`成功识别章节，共 ${chapters.length} 章`);
      
      // 处理章节：确保章节不会太长
      const processedChapters = [];
      
      chapters.forEach(chapter => {
        const chapterLength = chapter.endPosition - chapter.position;
        
        // 如果章节长度超过最大限制，进一步拆分
        if (chapterLength > maxCharsPerChapter * 2) {
          console.log(`章节 "${chapter.title}" 过长 (${chapterLength} 字符)，需进一步拆分`);
          
          // 计算需要拆分的数量
          const splitCount = Math.ceil(chapterLength / maxCharsPerChapter);
          const segmentLength = Math.ceil(chapterLength / splitCount);
          
          for (let i = 0; i < splitCount; i++) {
            const startPos = chapter.position + i * segmentLength;
            const endPos = Math.min(chapter.position + (i + 1) * segmentLength, chapter.endPosition);
            
            processedChapters.push({
              id: `${chapter.id}_${i}`,
              title: `${chapter.title}（${i + 1}/${splitCount}）`,
              position: startPos,
              endPosition: endPos,
              length: endPos - startPos
            });
          }
        } else {
          // 长度合适，直接添加
          processedChapters.push(chapter);
        }
      });
      
      return processedChapters;
    }
  } catch (err) {
    console.error('章节识别失败:', err);
  }
  
  // 如果章节识别失败，使用固定长度分割
  console.log('使用固定长度分割内容');
  const chunks = [];
  
  let position = 0;
  let chunkIndex = 0;
  
  while (position < content.length) {
    let endPosition = Math.min(position + maxCharsPerChapter, content.length);
    
    // 尝试在段落边界切分
    if (endPosition < content.length) {
      // 向后找最近的段落结束
      const nextNewline = content.indexOf('\n', endPosition);
      if (nextNewline !== -1 && nextNewline - endPosition < 500) {
        endPosition = nextNewline + 1;
      }
    }
    
    chunks.push({
      id: `chunk_${chunkIndex}`,
      title: `第 ${chunkIndex + 1} 部分`,
      position: position,
      endPosition: endPosition,
      length: endPosition - position
    });
    
    position = endPosition;
    chunkIndex++;
  }
  
  console.log(`分割完成，共 ${chunks.length} 个部分`);
  return chunks;
}

/**
 * 尝试检测内容编码，简化版
 * 前端版本不做实际检测，仅做兼容性保留
 */
export function detectEncoding(content) {
  // 在前端，我们实际上不做编码检测，这只是为了接口兼容性
  return 'utf8';
}

/**
 * 导出所有函数
 */
export {
  formatChapterContent
}; 